home *** CD-ROM | disk | FTP | other *** search
/ InfoMagic Internet Tools 1993 July / Internet Tools.iso / RockRidge / mail / pp / pp-6.0 / Lib / or / orn-dec.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-12-18  |  13.2 KB  |  530 lines
  1. /* orn-dec.c: routines to decode ORNames */
  2.  
  3. # ifndef lint
  4. static char Rcsid[] = "@(#)$Header: /xtel/pp/pp-beta/Lib/or/RCS/orn-dec.c,v 6.0 1991/12/18 20:23:08 jpo Rel $";
  5. # endif
  6.  
  7. /*
  8.  * $Header: /xtel/pp/pp-beta/Lib/or/RCS/orn-dec.c,v 6.0 1991/12/18 20:23:08 jpo Rel $
  9.  *
  10.  * $Log: orn-dec.c,v $
  11.  * Revision 6.0  1991/12/18  20:23:08  jpo
  12.  * Release 6.0
  13.  *
  14.  */
  15.  
  16. #include "MTA-types.h"
  17. #include "Ext-types.h"
  18.  
  19. #include "util.h"
  20. #include "or.h"
  21. #include "extension.h"
  22. #include "IOB-types.h"
  23. #include <isode/isoaddrs.h>
  24.  
  25. static int do_or_address (), do_addr_ext(), decode_adr_ext();
  26.  
  27. struct type_IOB_ORName *pe2orname (pe)
  28. PE    pe;
  29. {
  30.     struct type_IOB_ORName *orn;
  31.     
  32.     PP_PDUP (IOB_ORName, pe, "ORName", PDU_READ);
  33.  
  34.     if (decode_IOB_ORName (pe, 1, NULLIP, NULLVP, &orn) == NOTOK) {
  35.         PP_LOG (LLOG_EXCEPTIONS, ("Can't decode ORName [%s]",
  36.                       PY_pepy));
  37.         return NULL;
  38.     }
  39.     return orn;
  40. }
  41.  
  42. ORName *orname2orn(orn)
  43. struct type_IOB_ORName *orn;
  44. {
  45.     ORName    *orname;
  46.  
  47.     if (orn == (struct type_IOB_ORName *) NULL)
  48.         return NULLORName;
  49.  
  50.     orname = (ORName *)malloc (sizeof *orname);
  51.     if (do_or_address (&orname->on_or,
  52.                orn -> standard__attributes,
  53.                orn -> domain__defined,
  54.                orn -> extension__attributes) == NOTOK) {
  55.         PP_LOG(LLOG_EXCEPTIONS, ("Failed to decipher ORaddress"));
  56.         free ((char *)orname);
  57.         return NULLORName;
  58.     }
  59.  
  60.     if (orn->directory__name) {
  61.         PE dn = orn -> directory__name;
  62.  
  63.         if (dn -> pe_form != PE_FORM_CONS){
  64.             PP_LOG (LLOG_EXCEPTIONS, ("DN not a constructor form"));
  65.             ORName_free (orname);
  66.             return NULLORName;
  67.         }
  68.         if (decode_IF_Name (dn -> pe_cons, 1,
  69.                     NULLVP, NULLIP,
  70.                     &orname -> on_dn) == NOTOK) {
  71.             PP_LOG (LLOG_EXCEPTIONS, ("Can't decode DN [%s]",
  72.                           PY_pepy));
  73.             ORName_free(orname);
  74.             return NULLORName;
  75.         }
  76.     } else
  77.         orname -> on_dn = NULL;
  78.     return orname;
  79. }
  80.  
  81. ORName    *pe2orn(pe)
  82. PE    pe;
  83. {
  84.     struct type_IOB_ORName    *orn;
  85.     ORName    *orname;
  86.  
  87.     if ((orn = pe2orname(pe)) == NULL)
  88.         return NULLORName;
  89.  
  90.     orname = orname2orn(orn);
  91.     free_IOB_ORName (orn);
  92.     return orname;
  93. }
  94.  
  95. struct type_MTA_ORAddress *pe2oradr (pe)
  96. PE    pe;
  97. {
  98.     struct type_MTA_ORAddress    *ora;
  99.  
  100.     PP_PDUP (MTA_ORAddress, pe, "ORAddress", PDU_READ);
  101.  
  102.     if (decode_MTA_ORAddress (pe, 1, NULLIP, NULLVP, &ora) == NOTOK) {
  103.         PP_LOG (LLOG_EXCEPTIONS, ("Can't decode ORAddress [%s]",
  104.                       PY_pepy));
  105.         return NULL;
  106.     }
  107.     return ora;
  108. }
  109.  
  110. OR_ptr oradr2ora (ora)
  111. struct type_MTA_ORAddress    *ora;
  112. {
  113.     OR_ptr    or;
  114.     if(do_or_address (&or,
  115.               ora -> standard__attributes,
  116.               ora -> domain__defined__attributes,
  117.               ora -> extension__attributes) == NOTOK)
  118.         or = NULLOR;
  119.     return or;
  120. }
  121.  
  122. OR_ptr pe2ora (pe)
  123. PE    pe;
  124. {
  125.     struct type_MTA_ORAddress *ora;
  126.     OR_ptr or;
  127.     
  128.     if ((ora = pe2oradr(pe)) == NULL)
  129.         return NULLOR;
  130.     or = oradr2ora(ora);
  131.     free_MTA_ORAddress (ora);
  132.     return or;
  133. }
  134.  
  135. static int do_or_address (orp, std, dd, ext)
  136. OR_ptr *orp;
  137. struct type_MTA_StandardAttributes *std;
  138. struct type_MTA_DomainDefinedAttributes *dd;
  139. struct type_MTA_ExtensionAttributes *ext;
  140. {
  141.     struct type_MTA_OrganizationalUnitNames *ou;
  142.     OR_ptr    tree = NULLOR, or;
  143.     char    *p;
  144.     struct qbuf *qb;
  145.  
  146.     *orp = NULLOR;
  147. #define do_component(x,y,enc)    \
  148.     if (x) {\
  149.         or = or_new_aux (y, NULLCP, p = qb2str (x), (enc));\
  150.         free (p); \
  151.         if (or == NULLOR) return NOTOK; \
  152.         if (or_append (&tree, or) != OK)\
  153.             return NOTOK; \
  154.     }
  155.  
  156.     if (std) {
  157.         if (std -> country__name) {
  158.             qb = (std -> country__name -> offset ==
  159.                   type_MTA_CountryName_x121__dcc__code) ?
  160.                       std -> country__name -> un.x121__dcc__code :
  161.             std -> country__name ->
  162.                 un.iso__3166__alpha2__code;
  163.             do_component (qb, OR_C, OR_ENC_PS);
  164.         }
  165.         if (std -> administration__domain__name) {
  166.             qb = (std -> administration__domain__name -> offset ==
  167.                   type_MTA_AdministrationDomainName_numeric) ?
  168.                       std -> administration__domain__name ->
  169.                           un.numeric :
  170.             std -> administration__domain__name ->
  171.                 un.printable;
  172.             do_component (qb, OR_ADMD, OR_ENC_PS);
  173.         }
  174.         do_component (std -> network__address, OR_X121, OR_ENC_NUM);
  175.         do_component (std -> terminal__identifier, OR_TID, OR_ENC_PS);
  176.         if (std -> private__domain__name) {
  177.             qb = (std -> private__domain__name -> offset ==
  178.                   type_MTA_PrivateDomainName_numeric) ?
  179.                       std -> private__domain__name ->
  180.                           un.numeric :
  181.                       std -> private__domain__name ->
  182.                           un.printable;
  183.             do_component (qb, OR_PRMD, OR_ENC_PS);
  184.         }
  185.         do_component (std -> organization__name, OR_O, OR_ENC_PS);
  186.         do_component (std -> numeric__user__identifier, OR_UAID, OR_ENC_NUM);
  187.         if (std -> personal__name) {
  188.             do_component (std -> personal__name -> surname, OR_S, OR_ENC_PS);
  189.             do_component (std -> personal__name -> given__name,
  190.                       OR_G, OR_ENC_PS);
  191.             do_component (std -> personal__name -> initials, OR_I, OR_ENC_PS);
  192.             do_component (std -> personal__name ->
  193.                       generation__qualifier, OR_GQ, OR_ENC_PS);
  194.         }
  195.         for (ou = std -> organizational__unit__names;
  196.              ou; ou = ou -> next) {
  197.             do_component (ou -> OrganizationUnitName, OR_OU, OR_ENC_PS);
  198.         }
  199.     }
  200. #undef do_component
  201.     for ( ; dd; dd = dd -> next) {
  202.         char *q;
  203.  
  204.         or = or_new_aux (OR_DD,
  205.                  p = qb2str(dd -> DomainDefinedAttribute -> type),
  206.                  q = qb2str (dd -> DomainDefinedAttribute -> value),
  207.                  OR_ENC_PS);
  208.         free (q);
  209.         free (p);
  210.         if (or == NULLOR) return NOTOK;
  211.         if (or_append (&tree, or) != OK)
  212.             return NOTOK;;
  213.     }
  214.  
  215.     for (; ext; ext = ext -> next)
  216.         if (do_addr_ext (&tree, ext -> ExtensionAttribute) == NOTOK)
  217.             return NOTOK;
  218.     *orp = tree;
  219.     return OK;
  220. }
  221.  
  222. static int do_addrext_ps (treep, type, qb)
  223. OR_ptr *treep;
  224. int type;
  225. struct qbuf *qb;
  226. {
  227.     char *p;
  228.     OR_ptr or;
  229.     int retval;
  230.  
  231.     p = qb2str (qb);
  232.     or = or_new_aux (type, NULLCP, p, OR_ENC_PS);
  233.     if (or == NULLOR) return NOTOK;
  234.     retval = or_append (treep, or);
  235.     free (p);
  236.     return retval;
  237. }
  238.  
  239. static int do_addr_tt (treep, type, tt)
  240. OR_ptr *treep;
  241. int type;
  242. struct type_Ext_TerminalType *tt;
  243. {
  244.     char buf[64];
  245.     OR_ptr or;
  246.  
  247.     (void) sprintf (buf, "%d", tt -> parm);
  248.     or = or_new_aux (type, NULLCP, buf, OR_ENC_INT);
  249.     if (or == NULLOR) return NOTOK;
  250.     return or_append (treep, or);
  251. }
  252.  
  253. static int do_addrext_ttx (treep, type, qb)
  254. OR_ptr *treep;
  255. int type;
  256. struct qbuf *qb;
  257. {
  258.     char *p;
  259.     OR_ptr or;
  260.     int retval = OK;
  261.  
  262.     p = qb2str (qb);
  263.     if ((or = or_add_t61 (*treep, type, (unsigned char *)p,
  264.                   qb -> qb_len, 0)) == NULL)
  265.         retval = NOTOK;
  266.     else
  267.         *treep = or;
  268.     free (p);
  269.     return retval;
  270. }
  271.  
  272. static int do_addrext_psorns (treep, type, parm)
  273. OR_ptr *treep;
  274. int type;
  275. struct type_Ext_PostalCode *parm;
  276. {
  277.     char    *p;
  278.     OR_ptr or;
  279.     int retval = OK;
  280.  
  281.     switch (parm -> offset) {
  282.         case type_Ext_PostalCode_numeric__code:
  283.         p = qb2str (parm -> un.numeric__code);
  284.         or = or_new_aux (type, NULLCP, p, OR_ENC_NUM);
  285.         if (or == NULLOR)
  286.             return NOTOK;
  287.         retval = or_append (treep, or);
  288.         break;
  289.         case type_Ext_PostalCode_printable__code:
  290.         p = qb2str (parm -> un.printable__code);
  291.         or = or_new_aux (type, NULLCP, p, OR_ENC_PS);
  292.         if (or == NULLOR)
  293.             return NOTOK;
  294.         retval = or_append (treep, or);
  295.         default:
  296.         return NOTOK;
  297.     }
  298.     free (p);
  299.     return retval;
  300. }
  301.  
  302. static int do_addrext_pds (treep, type, parm)
  303. OR_ptr *treep;
  304. int type;
  305. struct type_Ext_PDSParameter *parm;
  306. {
  307.     int retval;
  308.     OR_ptr or;
  309.     char *p;
  310.  
  311.     if (parm -> printable__string) {
  312.         p = qb2str (parm -> printable__string);
  313.         or = or_new_aux (type, NULLCP, p, OR_ENC_PS);
  314.         free (p);
  315.         if (or == NULLOR) return NOTOK;
  316.         retval = or_append (treep, or);
  317.         if (retval != OK)
  318.             return retval;
  319.     }
  320.     if (parm -> teletex__string) {
  321.         p = qb2str (parm -> teletex__string);
  322.         or = or_add_t61 (*treep, type, (unsigned char *)p, 
  323.                  parm -> teletex__string -> qb_len, 0);
  324.         free (p);
  325.         if (or == NULL)
  326.             return NOTOK;
  327.         *treep = or;
  328.     }
  329.     return OK;
  330. }
  331.  
  332. /* ARGSUSED */
  333. static int do_addrext_ena (treep, type, parm)
  334. OR_ptr *treep;
  335. int type;
  336. struct type_Ext_ExtendedNetworkAddress *parm;
  337. {
  338.     OR_ptr or;
  339.     struct PSAPaddr *pa;
  340.  
  341.     switch (parm -> offset) {
  342.         case type_Ext_ExtendedNetworkAddress_e163__4__address:
  343.         if (parm -> un.e163__4__address -> number) {
  344.             char *p = qb2str (parm -> un.e163__4__address -> number);
  345.             or = or_new_aux (OR_ENA_N, NULLCP, p, OR_ENC_NUM);
  346.             free (p);
  347.             if (or == NULLOR) return NOTOK;
  348.             if (or_append (treep, or) == NOTOK)
  349.                 return NOTOK;
  350.         }
  351.         if (parm -> un.e163__4__address -> sub__address) {
  352.             char *p = qb2str (parm -> un.e163__4__address -> sub__address);
  353.             or = or_new_aux (OR_ENA_S, NULLCP, p, OR_ENC_NUM);
  354.             free (p);
  355.             if (or == NULLOR) return NOTOK;
  356.             if (or_append (treep, or) == NOTOK)
  357.                 return NOTOK;
  358.         }
  359.         break;
  360.  
  361.         case type_Ext_ExtendedNetworkAddress_psap__address:
  362.         if (parse_DSE_PSAPaddr (parm -> un.psap__address,
  363.                     1, NULLIP, NULLVP, &pa) == NOTOK)
  364.             return NOTOK;
  365.         or = or_new_aux (OR_ENA_P, NULLCP, 
  366.                  paddr2str(pa, NULLNA), OR_ENC_PSAP);
  367.         if (or == NULLOR) return NOTOK;
  368.         if (or_append (treep, or) == NOTOK)
  369.             return NOTOK;
  370.         break;
  371.  
  372.         default:
  373.         PP_LOG (LLOG_EXCEPTIONS, ("Unknown ena type %d",
  374.                       parm -> offset));
  375.         return NOTOK;
  376.     }
  377.     return OK;
  378. }
  379.  
  380. static int do_addr_ext (treep, ext)
  381. OR_ptr    *treep;
  382. struct type_MTA_ExtensionAttribute *ext;
  383. {
  384.     PY_pepy[0] = 0;
  385.  
  386. #define dec_axt(off, type, fnx, lab) \
  387.     decode_adr_ext (ext -> value, &_ZExt_mod,\
  388.             (off), (type), (fnx), (lab), treep)
  389.  
  390.     switch (ext -> type) {
  391.         case AEXT_CN:    /* common-name */
  392.         return dec_axt (_ZCommonNameExt, OR_CN, do_addrext_ps,
  393.                 "CommonName");
  394.  
  395.         case AEXT_TTXCN:    /* teletex-common-name */
  396.         return dec_axt (_ZTeletexCommonNameExt, OR_CN,
  397.                 do_addrext_ttx, "TelexCommonName");
  398.                        
  399.         case AEXT_TTXORG:        /* teletex-organization */
  400.         return dec_axt (_ZTeletexOrganizationNameExt, OR_O,
  401.                 do_addrext_ttx, "TeletexOrganizationName");
  402.  
  403.         case AEXT_TTXPN:        /* teletex-personal-name */
  404.         case AEXT_TTXOU:        /* teletex-organizational-unit-names */
  405.         case AEXT_TTXDD:        /* teletex-domain-defined-attributes */
  406.         break;
  407.         case AEXT_PDSNAME:        /* pds-name */
  408.         return dec_axt (_ZPDSNameExt, OR_PDSNAME,
  409.                 do_addrext_ps, "PDSName");
  410.  
  411.         case AEXT_PDCN:    /* physical-delivery-country-name */
  412.         return dec_axt (_ZPhysicalDeliveryCountryNameExt, OR_PD_C,
  413.                 do_addrext_psorns,
  414.                 "PhysicalDeliveryCountryName");
  415.  
  416.         case AEXT_POSTCODE:    /* postal-code */
  417.         return dec_axt (_ZPostalCodeExt, OR_POSTCODE,
  418.                 do_addrext_psorns, "PostalCode");
  419.  
  420.         case AEXT_PDONAME:    /* physical-delivery-office-name */
  421.         return dec_axt (_ZPhysicalDeliveryOfficeNameExt,
  422.                 OR_PDO_NAME, do_addrext_pds,
  423.                 "PhysicalDeliveryOfficeName");
  424.                        
  425.         case AEXT_PDONUMB:    /* physical-delivery-office-number */
  426.         return dec_axt (_ZPhysicalDeliveryOfficeNumberExt,
  427.                 OR_PDO_NUM, do_addrext_pds,
  428.                 "PhysicalDeliveryOfficeNumber");
  429.  
  430.         case AEXT_ORAC:    /* extension-OR-address-components */
  431.         return dec_axt (_ZExtensionORAddressComponentsExt,
  432.                 OR_OR_COMPS, do_addrext_pds,
  433.                 "ExtensionORAddressComponents");
  434.                        
  435.         case AEXT_PDPN:    /* physical-delivery-personal-name */
  436.         return dec_axt (_ZPhysicalDeliveryPersonalNameExt,
  437.                 OR_PD_PN, do_addrext_pds,
  438.                 "PhysicalDeliveryPersonalName");
  439.  
  440.         case AEXT_PDORG:    /* physical-delivery-organization-name */
  441.         return dec_axt (_ZPhysicalDeliveryOrganizationNameExt,
  442.                 OR_PD_O, do_addrext_pds,
  443.                 "PhysicalDeliveryOrganizationName");
  444.  
  445.         case AEXT_EPDAC:    /* extension-physical-delivery-address-components */
  446.         return dec_axt (_ZExtensionPhysicalDeliveryAddressComponentsExt,
  447.                 OR_PD_COMPS, do_addrext_pds,
  448.                 "ExtensionPhysicalDeliveryAddressComponents");
  449.  
  450.         case AEXT_UNFPA:    /* unformatted-postal-address */
  451.         break;
  452.  
  453.         case AEXT_STREET:    /* street-address */
  454.         return dec_axt (_ZStreetAddressExt, OR_STREET,
  455.                 do_addrext_pds, "StreetAddress");
  456.  
  457.         case AEXT_POBOX:    /* post-office-box-address */
  458.         return dec_axt (_ZPostOfficeBoxAddressExt, OR_PO_BOX,
  459.                 do_addrext_pds, "PostOfficeBoxAddress");
  460.  
  461.         case AEXT_POSTERES:    /* poste-restante-address */
  462.         return dec_axt (_ZPosteRestanteAddressExt,
  463.                 OR_PRA, do_addrext_pds,
  464.                 "PosteRestanteAddress");
  465.  
  466.         case AEXT_UNIQPA:    /* unique-postal-address */
  467.         return dec_axt (_ZUniquePostalNameExt,
  468.                 OR_UPN, do_addrext_pds,
  469.                 "UniquePostalName");
  470.  
  471.         case AEXT_LPA:    /* local-postal-attribute */
  472.         return dec_axt (_ZLocalPostalAttributesExt,
  473.                 OR_LPA, do_addrext_pds,
  474.                 "LocalPostalAttributes");
  475.  
  476.         case AEXT_NETADDR:    /* extended-network-address */
  477.         return dec_axt (_ZExtendedNetworkAddressExt,
  478.                 OR_ENA_S, do_addrext_ena,
  479.                 "ExtendedNetworkAddress");
  480.  
  481.         case AEXT_TT:    /* terminal-type */
  482.         return dec_axt (_ZTerminalTypeExt, OR_TT,
  483.                 do_addr_tt, "TerminalType");
  484.         default:
  485.         PP_LOG (LLOG_EXCEPTIONS, ("Unknown address extension %d",
  486.                       ext -> type));
  487.         break;
  488.     }
  489.     return OK;
  490. }
  491.  
  492. static int decode_adr_ext (petag, mod, offset, type, fnx, label, treep)
  493. PE    petag;
  494. modtyp *mod;
  495. int    offset;
  496. int    type;
  497. IFP    fnx;
  498. char    *label;
  499. OR_ptr    *treep;
  500. {
  501.     caddr_t genp;
  502.     int retval;
  503.     PE    pe;
  504.  
  505.     if (petag -> pe_class != PE_CLASS_CONT &&
  506.         petag -> pe_form != PE_FORM_CONS &&
  507.         petag -> pe_id != 1) {
  508.         PP_LOG (LLOG_EXCEPTIONS, ("Missing [1] tag in adr extension"));
  509.         return NOTOK;
  510.     }
  511.     pe = petag -> pe_cons;    /* strip off the tag */
  512. #if PP_DEBUG > 0
  513.         if (pp_log_norm -> ll_events & LLOG_PDUS)
  514.                 pvpdu (pp_log_norm, offset, mod,
  515.                pe, label, PDU_READ);
  516. #endif
  517.     if (dec_f (offset, mod, pe, 1, NULLIP, NULLVP, &genp) == NOTOK) {
  518.         PP_LOG (LLOG_EXCEPTIONS, ("Can't parse %s [%s]",
  519.                       label, PY_pepy));
  520.         return NOTOK;
  521.     }
  522.  
  523.     if ((retval = (*fnx) (treep, type, genp)) != OK)
  524.         return retval;
  525.  
  526.     (void) fre_obj ((char *)genp, mod -> md_dtab[offset], mod, 1);
  527.  
  528.     return OK;
  529. }
  530.